"""
@-*- coding: utf-8 -*-
@ python：python 3.8
@ 创建人员：ylx
@ 创建时间：2025/8/23 下午3:23
@ 内容：
"""
"""
@-*- coding: utf-8 -*-
@ python：python 3.8
@ 创建人员：ylx
@ 创建时间：2025/6/26 下午3:35
@ 内容：
"""
"""
字符串find方法，找到匹配的第一个，返回下标，找不到返回-1
字符串是不可变的数据类型
.replace(旧的，新的)，返回一个改变后的字符串，原始字符串不会被改变
upper() 大写
lower() 小写
strip() 处理字符串开头结尾的空格，不能处理中间的
.split() 分割字符串，成为一个列表,默认用空格，如果里边写空字符串会报错，可以写为" "等同于空格
还可以连接列表为字符串 "需要的字符串".join(list),列表中元素必须为字符串，因为你要用字符串拆分为列表，字符串列表再合并为整个字符串
str.count("") 有就返回统计的个数，没有就返回0 计数
str.startswith() 判断字符串用什么开头，返回布尔值
str.endswith() 判断字符串结尾 返回布尔值
字符串支持
isalpha() 若字符串中的所有字符都是字母，并且至少有一个字符，返回True
isdigit() 若字符串中所有字符串都是数字，并且至少有一个字符，返回True
isalnum() 字符都是字母或者数字，并且至少有一个，返回True

列表是可变 有序 可重复，支持索引和切片的
list 是一种非常灵活且常用的数据结构，用于存储一系列有序的元素，列表中的元素可以是
不同类型的数据，比如说整数，浮点数，字符串，列表，字典，元组等Python支持的数据类型
创建列表的简单的方式是就是直接使用[] 或者list() 可以创建空列表
也可以直接使用list()构造函数从可迭代对象来创建列表，比如说list("abd")  list((1,2,3))
得到的输出为["a", "b", "d"]   [1,2,3]
通过切片来访问元素
从0开始，区间切片是左闭右开，-1等于从尾巴开始

由于列表是可变数据类型，可以直接通过索引来修改元素
但是注意索引范围必须是当前列表的范围之内
使用list.append() 在列表的末尾添加一个元素
insert(索引，值) 在指定位置添加，这个位置本身的元素靠后,如果不是范围内的，则排到最后
list.extend(iterable) 扩展另一个可迭代对象

使用remove() 删除列表中首次出现的值,如果没有值，会报错
pop() 移除并返回指定位置的元素，默认移除最后一个元素,按索引可以删除，并返回这个元素
超范围的会报错,删除到最后空列表使用会报错
del关键字  可以删除列表中的某个切片或者删除整个列表 del list[索引]

可以使用切片来获取列表的一部分，也可以使用切片来修改多个元素
num[1:4] = [1,2,3]  就是将num列表中索引为1 2 3 的原值修改为 新值 1 2 3
list[0] = 新值，将这个位置原来的值更新为新值


如果同时要获取元素及索引 使用enumerate()
for index, fruit in enumerate(list):
    print(index, fruit)


list.index("值") 返回第一个等于x的元素的索引

sort()对列表进行原地排序
list.sort() 默认从小到大排序
aa = sorted(list) 返回一个已被排序的新列表，不改变原来的列表
len(list) 获取列表的长度，有多少个值
list.count(值)统计元素在列表中出现的次数
list.reverse() 反转列表中元素的顺序，原地翻转
list_1 = reversed(list) 新列表翻转，原列表不变
list.clear() 清空列表 原地修改方法，返回值是None，而不是清空后的列表[]
sum(list) 仅限数字列表
高级操作-列表推导式
list_1 = [x**2 for x in range[10]]

map()函数 应用函数至列表所有的元素
filter() 根据条件筛选列表元素
aa = list(map(lambda x: x**2, list_1))
bb = list(filter(lambda x: x%2 == 0, list_1))

复制列表，直接赋值不会创建列表的副本，而是2个变量指向同一个列表，如果要创建副本，使用切片或者copy()方法

在Python中元组是一种基础且常用的数据结构，也是Python的一种数据类型，它与列表类似，都是用来存储多个元素的序列
和列表的一个关键区别就是元组是不可变的，而列表是可变的
但是如果元组内我们放一个列表，我们可以切片得到这个列表，并对列表内的元素进行修改，这样看起来元组又是可变的
只不过是我们间接改变，但是对于元组本身来说，这里还是一个列表

我们通常使用一个()来定义一个元组
如这种l = () 这是一个空元组
一般我们可以省略括号如这样 l = 1,2,3 这其实也是一个元组
对于单元素的元组，我们使用这种表示 l = (5,)
l = (5) 不是一个元组，而是一个整数

也可以将元组转变为列表  列表转换为元组
如tuple([1,2,3]) 输出(1,2,3)


同列表一致，我们可以通过索引来访问元组内的元素，支持切片操作，但是不支持修改
因为元组是不可变的数据类型
支持遍历
支持拼接和重复，不会改变原有，而是生成新的元组
l1 = (1,2)
l2 = (3,4)
l3 = l1 + l2  输出  (1,2,3,4)
l4 = l1*2 输出 (1,2,1,2)

使用in 来判断元素是否在元组  列表  字符串内  返回布尔值

可以获取元组的长度  最值
len(tuple)
max(tuple)
min(tuple) 

元组的解包和打包
打包
t = 1,2,3
print(t)   (1,2,3)

x,y,z = t
print(x)
print(y)
print(z)  
一次打印 1 2 3,但是注意数量一定要匹配，否则会报错
或者可以用*来捕获剩余的
a, *b = t
print(a) 输出1
print(b) 输出[2,3] 注意这是一个列表

元组不可变，所以数据不会被意外修改，一般用来存储不变的数据，如配置项，常量，日期，时间，坐标等
其也可以作为字典的键，列表不能作为字典的键，但是元组可以
函数返回多个值时，实际上返回的是一个元组
元组的不可变 和高效（和列表来对比，元组更快）

python中集合用来存储不重复的元素，与数学中集合的概念非常类似
集合是一种无序，不重复元素的容器
集合无序，所以不能通过索引访问
集合内的元素具有唯一性，不允许有重复的元素
集合是可变数据类型，但是集合中的元素必须是不可变类型的数据，如整数，字符串，元组
集合允许添加或删除元素，但是不能修改已有元素，这应该是因为集合内部是无序的
使用{1,2,3} 或者 a = set() 创建空集合
{} 不是空集合，表示字典
集合常用操作
set.add(1)
set.remove(2) ,若不存在该元素则会报错 KeyError
set.discard(2) , 安全删除，不存在的元素不会报错
set.clear() 清空集合
len(set) 集合长度

集合的运算
| 并,大家一起有的-全集
& 交,2个一起有的
A-B 差,前者单独有的，仅属于A但是不属于B
^ 2个人各自单独有的，组成新的集合

集合关系判断
set.issubset(b) 是否为子集  判断set是不是b集合的子集 返回布尔值，满足返回True
set.issuperset(b) 是否为父集  判断set是不是b集合的父集 返回布尔值，满足返回True
set.isdisjoint(b) 是否没有交集  返回布尔值，无交集返回True

如果你希望你的集合是不可变的，比如说作为字典的键，使用frozenset(set)

集合的常见应用场景未，快速去重列表中的重复项，统计数据集之间的差异，交集等，集合的查找速度比列表快


字典是一种可变，无序的，key/value组成每一个元素
键唯一，若重复，后面的会覆盖前面的
字典可以增删改
使用{}来创建空字典 或者直接a = dict() 也可以创建空字典
可以使用元组列表构造 dict([("name","alice")]) 

取值通过 a[key] = value 通过键来获取值，如果键不存在，则会抛出KeyError的错误
如果想安全获取，使用dict.get()，获取不到输出None，也可以指定默认的值，dict.get("value", "指定获取不到时返回的值")
添加或修改键值对
a[新键] = 新值 字典的添加
a[原来存在的键] = 新值 字典的修改

删除键值对
del d[键]

aa = dict.pop(键) 删除后返回对应的值      注意必须写键名

dict.clear() 清空字典


遍历字典

for key in dict:
    print(key)  遍历键


for value in dict.values():
    print(value) 遍历值


for a,b in dict.items():
    print(a,b) 遍历键值对


判断键是否存在
if a in dict:


合并2个字典
d1.update(d2) 先展示d1的，然后d2，若有重复的，后面的覆盖前面的

字典的合法键必须是不可变数据类型的 如整数 浮点数， 布尔值 字符串 元组(要求元组内的元素均为不可变数据类型)
冻结集合

键不能是 可变数据类型，如列表 字典 集合
值没有要求，是Python支持的数据类型即可

dict.items() 返回一个视图对象 view object 包含了字典中所有的键值对，每个元素是一个元组
如果要打印返回的type 则是 dict_items
支持遍历，可以同时拿到键和值

还有dict.keys() dict.values() 这2种分别仅获取字典的键 或者字典的值



"""

# a = "1213456"
# b = "1 2 3"
# final_a = a.replace("121", "88")
# print(a.find("1"))
# print(a.find("8"))
# print(a)
# print(final_a)
# print(b.split(" "))
# c = ["name", "age", "sex"]
# print("".join(c), type("".join(c)))
# print(a.count("1"))
# print(a.count("1212"))
# c.insert(5, "haha")
# print(c)
# cc = [1]
# print(cc.pop())
# print(c)
# print(cc.pop())
# print(c)

# ccc = (1, [2, 3, 4])
# ccc[1][0] = 22
# print(ccc)
# c.remove("name")
# print(c)
# # c.remove("name")
# dd = (1, 2, 3)
# a,b,c = dd
# print(a, type(a))
# print(b, type(b))

# aaaa = [1,2,3]
# b = frozenset(aaaa)
# print(b)

# for i in range(1, 10):
#     for j in range(1, i+1):
#         print(f"{j}*{i}={i*j}\t", end=" ")
#     print("")


# class Learn:
#
#     weather = "sunday"
#
#     def __init__(self, name, age):
#         self.name = name
#         self._age = age
#
#
#     @property
#     def age(self):
#         print("获取 age 属性")
#         return self._age
#
#     @age.setter
#     def age(self, value):
#         print("设置 age 属性")
#         if value < 0:
#             raise ValueError("年龄不能为负数")
#         self._age = value
#
#     @age.deleter
#     def age(self):
#         print("删除 age 属性")
#         del self._age
#
#     def say_hello(self, friend_name):
#         print(f"{self.name} say {friend_name} good morning")
#
#     @classmethod
#     def stu_info(cls, sex):
#         print(f"{cls.weather} and {sex}")
#
#     @staticmethod
#     def stu_like():
#         print("i love you")
#         print(f"{Learn.weather}")
#         Learn.stu_info("boy and girl")


# li = Learn("liming", 18)
# print("--------")
# print(li._age)
# li._age = -18
# print(li._age)
# print("---------")
# print(li.age)
# del li.age
# print(li.age)
# print("---")
# print(li.name)
# print("---")
#
# print("---")
# li.name = "xiao_ha"
# print(li.name)
# print("---")
#
# li.say_hello("xiao_hei")
# li.stu_like()
# li.stu_info("boy")
# print("----")
#
# Learn.stu_info("girl")
# Learn.stu_like()

# def decorator(func):
#     def wrapper(*args, **kwargs):
#         print("good morning")
#         res = func(*args, **kwargs)
#         print("thank you")
#         return res
#
#     return wrapper
#
#
# @decorator
# def say_hello(name):
#     print(f"{name} say hello for you")
#
#
# say_hello("xiao_hei")
# print(say_hello.__name__)


# print([0 + _ for _ in range(5)])


# def factory_decorator(nums, teacher_name):
#     def decorator_a(func):
#         print(f"你要说{nums}次，告诉别人")
#
#         def wrapper(*args, **kwargs):
#             print(f"{teacher_name} 说开始")
#             res = None
#             for i in range(nums+1):
#                 print(f"这是我第{i}次跟你说")
#                 res = func(*args, **kwargs)
#             print("结束")
#             return res
#         return wrapper
#     return decorator_a
#
#
# @factory_decorator(3, "wang_teacher")
# def say_hello(name):
#     print(f"{name} say hello world for you")
#     return 1
#
#
# say_hello("xiao_li")


# class People:
#     def __init__(self, age, name):
#         self.name = name
#         self._age = age
#
#     @property
#     def age(self):
#         return self._age
#
#     @age.setter
#     def age(self, value):
#         if value <= 0:
#             raise ValueError("年龄必须大于0")
#         else:
#             self._age = value
#
#
#     @age.deleter
#     def age(self):
#         print("开始删除")
#         del self._age
#
#
# aa = People(1, "xiao_wang")
#
# print(aa.name)
# print(aa.age)
# print(aa.__dict__)
#
# del aa.age
# print(aa.__dict__)


# aa = (1, 2)
# bb = aa*3
# cc = aa + bb
# print(bb)
# print(cc)

# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right


# list_b = [1, 2, 3]
# ans = TreeNode(list_b[0])
# que_1 = deque()
# print("---")
# print(deque([ans]))
# print("---")
# print(deque(ans))
# print("---")


# que = deque()
# two_tree_1 = TreeNode(1)
# list_a = [1, 2, 3, 4]
# list_c = [[1, 2], 3, 6]
# str_a = "hello"
#
# aa = deque(list_c)
# print(aa, type(aa))
# print(two_tree_1, type(two_tree_1))
# aa.append(two_tree_1)
# print(aa)
# print(deque(list_a))
# print(deque([list_a]))
# print(deque(str_a))

# a = list().append(1)
# print(a)

# a = list([1, [2, 3]])
# print(a)
#
# b = deque([1, [2, 3]])
# print(b)


# 比赛次数，比赛成绩，选手ID ,从高到低排序选手ID
# a = int(input())
# b = list(map(int, input().split()))
# c = list(map(int, input().split()))
# list_id_score = list(zip(b, c))
# print(list_id_score)
#
# str_b = "".join(list(map(str, b)))
# str_bb = ""
# for i in str_b:
#     if str_b.count(i) >= 3:
#         if i not in str_bb:
#             str_bb += i
#     else:
#         pass
#
# ok_id = list(map(int, list(str_bb)))
# print(ok_id)
#
# ok_id_score = []
#
# for i in list_id_score:
#     if i[0] in ok_id:
#         ok_id_score.append(i)
#     else:
#         pass
#
# print(ok_id_score)
#
#
# ok_id_score_dict = {}
# for j in ok_id_score:
#     if j[0] not in ok_id_score_dict:
#         ok_id_score_dict[j[0]] = j[1]
#     else:
#         ok_id_score_dict[j[0]] = ok_id_score_dict[j[0]] + j[1]
#
# print(ok_id_score_dict)
# res = list(ok_id_score_dict.items())
# res.sort(key=lambda x: (x[1], x[0]), reverse=True)
#
# id_sort = []
# for i in res:
#     id_sort.append(i[0])
#
# print(id_sort)


# 滑动窗口题目，固定滑窗，一定的列表，输出滑窗内最大的值
# from collections import deque
#
#
# def slide_window(nums, k):
#     if not nums:
#         return []
#
#     res = []
#     n = len(nums)
#     dq = deque()
#
#     for i in range(n):
#         while dq and dq[0] < i - k +1:
#             dq.popleft()
#
#         while dq and nums[dq[-1]] < nums[i]:
#             dq.pop()
#
#
#         dq.append(i)
#
#         if i >= k - 1:
#             res.append(nums[dq[0]])
#
#     return res
#
#
# nums = [1, 2, 3, 4, 5, 6]
# k = 3
# print(slide_window(nums, k))


# ------
# print(list([1]))
# print(list([[1]]))
# a = list()
# a.append(1)
# print(a)
# ------

# def animal(*args, **kwargs):
#     print(f"args是{args}")
#     print(f"kwargs是{kwargs}")
#     print(f"{kwargs['name']}")
#
#
# dict_1 = {"name": "cat", "age": 18}
# tuple_1 = (1, 2, 3)
#
# animal(*tuple_1, **dict_1)
# # 针对函数来说，形式参数会有* **，单个* 在函数内部会被变为元组，**会在函数内部变为字典
# # 但是针对方法实例来说，里边的实际参数，*会解包，将元组变为1, 2, 3 **会解包字典变为name="cat"


# ------不含参数的装饰器写法-简单
# def decorator(func):
#     def wrapper(*args, **kwargs):
#         print("good_morning")
#         func(*args, **kwargs)
#         print("thank_you")
#
#     return wrapper
#
#
# @decorator
# def animal(name, age, sounds):
#     print(f"{name} is {age},sounds is {sounds}")
#
#
# animal("xiao_hei", 18, "ha_ha")
# ------


# ------含参装饰器-增加动物类别
# def animal_all(m):
#     def decorator(func):
#         def wrapper(*args, **kwargs):
#             print(f"the animal is {m}")
#             print("start")
#             func(*args, **kwargs)
#             print("end")
#
#         return wrapper
#     return decorator
#
#
# @animal_all("tiger")
# def animal(name, age, sounds):
#     print(f"{name} is {age},sounds is {sounds}")
#
#
# animal("xiao_hei", 18, "ha_ha")
# ------


'''
给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

solution_1:暴力双循环，计算从左开始，每个长方形的面积，取最大，劣势-能通过部分用例，但是一旦数量变大，则无法通过，双循环我认为
是暴力解法的一种

solution_2:
'''
# class Solution:
#     def maxArea(self, height) -> int:
#         list_a = []
#         max_water = 0
#         for a, b in enumerate(height):
#             list_a.append((a + 1, b))
#
#
#         for m in range(len(list_a)-1):
#             for n in range(m+1, len(list_a)):
#                 start_x = list_a[m][0]
#                 start_y = list_a[m][1]
#                 end_x = list_a[n][0]
#                 end_y = list_a[n][1]
#                 res = (end_x - start_x) * min(start_y, end_y)
#                 max_water = max(max_water, res)
#
#         return max_water
#
#
#         贪心 + 双指针
#         max_water = 0
#         left = 0
#         right = len(height) - 1
#
#         # 当且仅当左边比右边小时，计算面积
#         while left < right:
#             width = right - left
#             heights = min(height[left], height[right])
#             res = width * heights
#             max_water = max(max_water, res)
#
#
#             if height[left] <=  height[right]:
#                 left += 1
#             else:
#                 right -= 1
#
#         return max_water


# res_test = Solution()
# nums = [1, 8, 6, 2, 5, 4, 8, 3, 7]
# print(res_test.maxArea(nums))


# class Solution:
#     def intToRoman(self, num: int) -> str:
#         roma_nums_1 = ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"]
#         roma_nums_2 = ["", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"]
#         roma_nums_3 = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"]
#         roma_nums_4 = ["", "M", "MM", "MMM"]
#         roma_nums = [roma_nums_1, roma_nums_2, roma_nums_3, roma_nums_4]
#
#         num_list = list(str(num))
#         num_list.reverse()
#         new_num_list = list(map(int, num_list))
#         print(new_num_list)
#
#         aa_nums = []
#         for i in range(len(new_num_list)):
#             res_one = new_num_list[i] * (10 ** i)
#             aa_nums.append(res_one)
#
#         print(aa_nums)
#
#         res_1 = []
#         for mm in range(len(aa_nums)):
#             index_res = int(aa_nums[mm]/(10**mm))
#             res_1.append(index_res)
#
#         print(res_1)
#
#         res_2 = []
#         for i in range(len(res_1)):
#             res_2.append(roma_nums[i][res_1[i]])
#
#
#         res_2.reverse()
#         res_end = "".join(res_2)
#
#         return res_end
#
#
#
# res = Solution()
# nums = 3749
# print(res.intToRoman(nums), type(res.intToRoman(nums)))

'''
三数之和
'''
# class Solution:
#     def threeSum(self, nums):
#
#         if len(nums) < 3:
#             return []
#
#         if len(nums) == 3:
#             if nums[0] + nums[1] + nums[2] == 0:
#                 return [nums]
#             else:
#                 return []
#
#         nums.sort()
#         res_end = []
#
#         for i in range(0, len(nums)):
#             print(f"进入for循环-目前下标i是:{i}")
#             if nums[i] > 0:
#                 return res_end
#
#             if i > 0 and nums[i] == nums[i - 1]:
#                 print("进入去重 i 的判断逻辑")
#                 continue
#
#             ll = i + 1
#             rr = len(nums) - 1
#
#             while ll < rr:
#                 print(f"进入while计算循环，ll下标:{ll}, rr下标:{rr}")
#
#                 if nums[i] + nums[ll] + nums[rr] == 0:
#                     print("进入if判断，此时和为0")
#                     res_end.append([nums[i], nums[ll], nums[rr]])
#
#                     while ll < rr and nums[ll] == nums[ll + 1]:
#                         print(f"进入while去重 ll下标 循环，ll下标:{ll}, rr下标:{rr}")
#                         ll += 1
#
#                     while rr > ll and nums[rr] == nums[rr - 1]:
#                         print(f"进入while去重 rr下标 循环，ll下标:{ll}, rr下标:{rr}")
#                         rr -= 1
#
#                     ll += 1
#                     rr -= 1
#
#                     if ll == rr:
#                         print("准备终止本轮for循环，进入下一轮for循环")
#                         print("------")
#                     else:
#                         print("本轮for循环继续")
#
#                 elif nums[i] + nums[ll] + nums[rr] > 0:
#                     rr -= 1
#
#                 else:
#                     ll += 1
#
#         return res_end
#
#
# pp = Solution()
# nums = [-1, 0, 1, 2, -1, -4]
# nums_1 = [0, 0, 0, 0]
# nums_2 = [-1, -1, 0, 1]
# # res: [[-1,-1,2],[-1,0,1]
# print(pp.threeSum(nums_2))
#
# nums_sort = [-4, -1, -1, 0, 1, 2]

'''
空格：读入字符串并丢弃无用的前导空格（" "）
符号：检查下一个字符（假设还未到字符末尾）为 '-' 还是 '+'。如果两者都不存在，则假定结果为正。
转换：通过跳过前置零来读取该整数，直到遇到非数字字符或到达字符串的结尾。如果没有读取数字，则结果为0。
舍入：如果整数数超过 32 位有符号整数范围 [−2的31次方,  2的31次方 − 1] ，需要截断这个整数，使其保持在这个范围内
具体来说，小于 −2的31次方 的整数应该被舍入为 −2的31次方 ，大于 2的31次方 − 1 的整数应该被舍入为 2的31次方 − 1 。
返回整数作为最终结果。

输入：s = "0-1"
输出：0
解释：
第 1 步："0-1" (当前没有读入字符，因为没有前导空格)
第 2 步："0-1" (当前没有读入字符，因为这里不存在 '-' 或者 '+')
第 3 步："0-1" (读入 "0"；由于下一个字符不是一个数字，所以读入停止)
'''
# class Solution:
#     def myAtoi(self, s: str) -> int:
#         res = []
#         res_1 = []
#         res_2 = []
#         res_nums = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "+", "-", "."]
#         res_nums_1 = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]
#         res_num = ''
#         aa = s.strip()
#         if aa.startswith("-"):
#             res_num = "-"
#
#         if len(aa) == 0:
#             return 0
#
#
#         for i in range(len(aa)):
#             if aa[i] not in res_nums:
#                 if not res:
#                     return 0
#                 else:
#                     break
#             else:
#                 res.append(aa[i])
#
#         if res[0] == "-" or res[0] == "+":
#             res.pop(0)
#
#
#         print(f"第一次处理后的字符串列表{res}")
#
#         for j in res:
#             if j in res_nums_1:
#                 res_1.append(j)
#             else:
#                 break
#
#         print(f"第二次处理后的字符串列表{res_1}")
#
#         n = 0
#         for k in res_1:
#             if k == "0" and n == 0:
#                 continue
#             res_2.append(k)
#             n += 1
#
#         print(f"第三次处理后的字符串列表{res_2}")
#
#
#
#         if not res_2:
#             return 0
#
#         res_end = res_num + "".join(res_2)
#
#         aa_1 = int(res_end)
#         if (-2)**31 < aa_1 < (2**31 - 1):
#             return aa_1
#         elif aa_1 <= (-2)**31:
#             return (-2)**31
#         else:
#             return (2**31) - 1

# ss = Solution()
# s_1 = "0-1"
# # 输出：0
# s_2 = "1337c0d3"
# # 输出：1337
# s_3 = " -042"
# # 输出：-42
# s_4 = "words and 987"
#
# s_5 = "100"
# print(ss.myAtoi(s_3))
# print(ss.myAtoi(s_2))
# print(ss.myAtoi(s_1))
# print(ss.myAtoi(s_4))
# print(ss.myAtoi(s_5))

'''
给你一个长度为 n 的整数数组 nums 和 一个目标值 target
请你从 nums 中选出三个整数，使它们的和与 target 最接近。
返回这三个数的和。
假定每组输入只存在恰好一个解。

提示:
3 <= nums.length <= 1000
-1000 <= nums[i] <= 1000
-104 <= target <= 104
'''
# class Solution:
#     def threeSumClosest(self, nums, target):
#
#         if not nums or len(nums) < 3:
#             return None
#
#         if len(nums) == 3:
#             return sum(nums)
#
#         nums.sort()
#         print(f"排序后的nums{nums}")
#         print(f"目标值为:{target}")
#         sums_target = float("inf")
#         for i in range(len(nums)):
#             print(f"for循环的i:{i}")
#             if i > 0 and nums[i] == nums[i - 1]:
#                 continue
#
#             ll = i + 1
#             rr = len(nums) - 1
#             while ll < rr:
#                 sums_res = nums[i] + nums[ll] + nums[rr]
#                 cc = sums_res - target
#                 if cc == 0:
#                     print("若出现cc为0的情况，直接返回target")
#                     return target
#                 if abs(cc) < abs(sums_target - target):
#                     sums_target = sums_res
#                 if cc < 0:
#                     ll += 1
#                 else:
#                     rr -= 1
#
#         return sums_target
#
#
# nums_1 = [-1, 2, 1, -4]
# target_1 = 1
# # 输出 2
# nums_2 = [0, 0, 0]
# target_2 = 1
# # 输出 0
#
# nums_3 = [4, 0, 5, -5, 3, 3, 0, -4, -5]
# target_3 = -2
# # 输出 -2
#
# nums_4 = [-4, 2, 2, 3, 3, 3]
# target_4 = 0
# # 输出 0
#
# nums_5 = [-1000, -5, -5, -5, -5, -5, -5, -1, -1, -1]
# target_5 = -8
# # 输出 -7
#
# aa = Solution()
# print("res:", aa.threeSumClosest(nums_1, target_1))
# # print("res:", aa.threeSumClosest(nums_2, target_2))
# # print("res:", aa.threeSumClosest(nums_3, target_3))
# # print("res:", aa.threeSumClosest(nums_4, target_4))
# # print("res:", aa.threeSumClosest(nums_5, target_5))


'''
电话号码组合问题
'''
# class Solution:
#     def letterCombinations(self, digits):
#         str_2 = ["a", "b", "c"]
#         str_3 = ["d", "e", "f"]
#         str_4 = ["g", "h", "i"]
#         str_5 = ["j", "k", "l"]
#         str_6 = ["m", 'n', "o"]
#         str_7 = ["p", "q", "r", "s"]
#         str_8 = ["t", "u", "v"]
#         str_9 = ["w", "x", "y", "z"]
#         str_all = ['', '', str_2, str_3, str_4, str_5, str_6, str_7, str_8, str_9]
#
#         list_digits_int = list(map(int, list(digits)))
#         print(f"处理传入的字符串，转换为整型列表{list_digits_int}")
#
#         # 处理字符串长度为1的情况，返回数字对应的列表
#         if len(list_digits_int) == 1:
#             print(f"传入字符串长度为1，直接取str_all对应索引位置的列表")
#             res_index = int(digits)
#             res = str_all[res_index]
#             return res
#
#         # 处理字符串为空的情况
#         if digits.strip() == "":
#             print(f"字符串为空，返回空列表")
#             return []
#
#
#         # 处理字符串的长度大于1的情况
#         # 举例-传入“123”
#         # 思路：先把传入参数的，第一个数字对应的列表取出来，然后此时遍历剩下的数字
#         # 取对应的列表，借助一个中间空的list 的append 和 pop操作
#         # 其实对我来说 我只要处理当前和下一个的匹配关系并存起来，其实永远都是2个的关系
#         start_list = str_all[list_digits_int[0]]
#         print(f"头部数字的列表值:{start_list}")
#
#         res_list_1 = []
#         for i in range(1, len(list_digits_int)):
#             res_list_2 = []
#
#             res_list_1.append(str_all[list_digits_int[i]])
#             print(f"待消费列表:{res_list_1}")
#             cc = res_list_1.pop()
#
#             for m in cc:
#                 for j in start_list:
#                     res_list_2.append(j + m)
#
#             start_list = res_list_2[:]
#             print(f"新的开始列表:{start_list}")
#
#
#         print(f"结果:{start_list}")
#         return start_list
#
#
# ss = Solution()
# str_nums_1 = "2"
# str_nums_2 = "234"
# # 输出 ["ad","ae","af","bd","be","bf","cd","ce","cf"]
# print(ss.letterCombinations(str_nums_2))

